package com.ruoyi.service.impl;

import java.util.*;
import java.util.stream.Collectors;

import com.ruoyi.common.annotation.DataSource;
import com.ruoyi.common.enums.DataSourceType;
import com.ruoyi.domain.TtsAx;
import com.ruoyi.resp.DeviceLocationStats;
import com.ruoyi.resp.LocationDeviceStats;
import com.ruoyi.resp.PointType;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.mapper.TtsAxMapper;
import com.ruoyi.service.ITtsAxService;

/**
 * 消控点位Service业务层处理
 * 
 * @author li
 * @date 2025-08-18
 */
@Service
public class TtsAxServiceImpl implements ITtsAxService 
{
    @Autowired
    private TtsAxMapper ttsAxMapper;

    /**
     * 查询消控点位
     * 
     * @param id 消控点位主键
     * @return 消控点位
     */
    @Override
    public TtsAx selectTtsAxById(String id)
    {
        return ttsAxMapper.selectTtsAxById(id);
    }

    /**
     * 查询消控点位列表
     * 
     * @param ttsAx 消控点位
     * @return 消控点位
     */
    @Override
    public List<TtsAx> selectTtsAxList(TtsAx ttsAx)
    {
        return ttsAxMapper.selectTtsAxList(ttsAx);
    }

    /**
     * 新增消控点位
     * 
     * @param ttsAx 消控点位
     * @return 结果
     */
    @Override
    public int insertTtsAx(TtsAx ttsAx)
    {
        return ttsAxMapper.insertTtsAx(ttsAx);
    }

    /**
     * 修改消控点位
     * 
     * @param ttsAx 消控点位
     * @return 结果
     */
    @Override
    public int updateTtsAx(TtsAx ttsAx)
    {
        return ttsAxMapper.updateTtsAx(ttsAx);
    }

    /**
     * 批量删除消控点位
     * 
     * @param ids 需要删除的消控点位主键
     * @return 结果
     */
    @Override
    public int deleteTtsAxByIds(String[] ids)
    {
        return ttsAxMapper.deleteTtsAxByIds(ids);
    }

    /**
     * 删除消控点位信息
     * 
     * @param id 消控点位主键
     * @return 结果
     */
    @Override
    public int deleteTtsAxById(String id)
    {
        return ttsAxMapper.deleteTtsAxById(id);
    }

    @Override
    public List<PointType> getPointType() {
        List<TtsAx> ttsAxes = ttsAxMapper.selectTtsAxList(null);
        //获取所有点位,根据点位类型进行分组统计数量
        // 2. 使用 Stream API 按点位类型分组并统计数量
        Map<String, Long> typeCountMap = ttsAxes.stream()
                .collect(Collectors.groupingBy(
                        TtsAx::getType, // 按点位类型分组
                        Collectors.counting() // 统计每个组的数量
                ));
        // 3. 转换为 PointType 对象列表
        List<PointType> result = typeCountMap.entrySet().stream()
                .map(entry -> {
                    PointType pointType = new PointType();
                    pointType.setName(entry.getKey()); // 点位类型名称
                    pointType.setCount(String.valueOf(entry.getValue().intValue())); // 数量
                    return pointType;
                })
                .collect(Collectors.toList());
        return result;
    }

    @Override
    public List<LocationDeviceStats> getPointXfType() {
        // 1. 获取所有设备数据
        List<TtsAx> allDevices = ttsAxMapper.selectTtsAxList(null);
        // 2. 按地点分组，再按设备类型分组统计
        Map<String, Map<String, Long>> groupedStats = allDevices.stream()
                .collect(Collectors.groupingBy(
                        device -> device.getLocation() != null&&!device.getLocation().equals("") ? device.getLocation() : "未知地点",
                        Collectors.groupingBy(
                                device -> device.getType() != null ? device.getType() : "未知设备类型",
                                Collectors.counting()
                        )
                ));
        // 3. 转换为结果对象
        List<LocationDeviceStats> result = new ArrayList<>();
        for (Map.Entry<String, Map<String, Long>> locationEntry : groupedStats.entrySet()) {
            String location = locationEntry.getKey();
            LocationDeviceStats stats = new LocationDeviceStats(location);
            for (Map.Entry<String, Long> typeEntry : locationEntry.getValue().entrySet()) {
                stats.addDeviceTypeCount(typeEntry.getKey(), typeEntry.getValue().intValue());
            }
            result.add(stats);
        }
        // 4. 按地点名称排序
        result.sort(Comparator.comparing(LocationDeviceStats::getName));
        return result;
    }

    @Override
    public List<DeviceLocationStats > getPointByNameType() {
        // 1. 获取所有设备数据
        List<TtsAx> allDevices = ttsAxMapper.selectTtsAxList(null);
        // 2. 按设备类型分组，收集位置列表
        Map<String, Set<String>> groupedStats = allDevices.stream()
                .collect(Collectors.groupingBy(
                        device -> device.getType() != null &&!device.getType().equals("未定义")&&!device.getType().equals("")? device.getType() : "未知设备类型",
                        Collectors.mapping(
                                device -> device.getLocation() != null ? device.getLocation() : "未知位置",
                                Collectors.toSet()
                        )
                ));
        // 3. 转换为结果对象
        List<DeviceLocationStats> result = new ArrayList<>();
        for (Map.Entry<String, Set<String>> entry : groupedStats.entrySet()) {
            DeviceLocationStats  stats = new DeviceLocationStats (entry.getKey());
            stats.setLocations(new ArrayList<>(entry.getValue()));
            result.add(stats);
        }
        // 4. 按设备类型排序
        result.sort(Comparator.comparing(DeviceLocationStats::getDeviceType));

        return result;
    }
}
